#!/usr/bin/env node

/**
 * AIDE 数据库初始化脚本 - 修复版本
 * 解决URL解析和权限问题
 */

const { Pool } = require('pg')
const fs = require('fs')
const path = require('path')

// 解析DATABASE_URL（处理密码中的特殊字符）
function parseDatabaseUrl(url) {
  try {
    // 手动解析以处理密码中的@符号
    const match = url.match(/^postgresql:\/\/([^:]+):(.+)@([^:]+):(\d+)\/(.+)$/)
    if (match) {
      const [, username, password, host, port, database] = match
      return {
        user: username,
        password: password,
        host: host,
        port: parseInt(port),
        database: database,
        ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
      }
    }
    
    // 如果正则匹配失败，尝试使用URL对象（但可能有问题）
    const urlObj = new URL(url)
    return {
      user: urlObj.username,
      password: urlObj.password,
      host: urlObj.hostname,
      port: parseInt(urlObj.port || '5432'),
      database: urlObj.pathname.slice(1),
      ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
    }
  } catch (error) {
    console.error('❌ DATABASE_URL解析失败:', error.message)
    console.error('📝 正确格式: postgresql://username:password@host:port/database')
    throw error
  }
}

// 获取数据库配置
const getDatabaseConfig = () => {
  if (process.env.DATABASE_URL) {
    return parseDatabaseUrl(process.env.DATABASE_URL)
  }
  
  return {
    host: process.env.DB_HOST || 'localhost',
    port: parseInt(process.env.DB_PORT || '5432'),
    database: process.env.DB_NAME || 'aide_db',
    user: process.env.DB_USER || 'postgres',
    password: process.env.DB_PASSWORD || 'password',
  }
}

// 创建数据库
async function createDatabase() {
  const config = getDatabaseConfig()
  const targetDatabase = config.database
  
  // 连接到默认的 postgres 数据库来创建目标数据库
  const adminConfig = {
    ...config,
    database: 'postgres' // 连接到默认数据库
  }
  
  console.log('🔧 尝试连接到PostgreSQL服务器...')
  console.log(`   用户: ${adminConfig.user}`)
  console.log(`   主机: ${adminConfig.host}:${adminConfig.port}`)
  
  const pool = new Pool(adminConfig)
  
  try {
    const client = await pool.connect()
    console.log('✅ 成功连接到PostgreSQL服务器')
    
    // 检查数据库是否存在
    const result = await client.query(
      'SELECT 1 FROM pg_database WHERE datname = $1',
      [targetDatabase]
    )
    
    if (result.rows.length > 0) {
      console.log(`✅ 数据库 "${targetDatabase}" 已存在`)
      client.release()
      return true
    }
    
    // 创建数据库
    console.log(`🔧 创建数据库 "${targetDatabase}"...`)
    await client.query(`CREATE DATABASE "${targetDatabase}"`)
    console.log(`✅ 数据库 "${targetDatabase}" 创建成功`)
    
    client.release()
    return true
    
  } catch (error) {
    console.error('❌ 创建数据库失败:', error.message)
    
    if (error.code === 'ECONNREFUSED') {
      console.error('💡 PostgreSQL服务未运行，请检查:')
      console.error('   sudo systemctl status postgresql')
      console.error('   sudo systemctl start postgresql')
    } else if (error.code === '28P01') {
      console.error('💡 认证失败，请检查用户名和密码')
      console.error('   当前用户:', adminConfig.user)
      console.error('   密码长度:', adminConfig.password ? adminConfig.password.length : 0)
    } else if (error.code === '3D000') {
      console.error('💡 无法连接到postgres数据库，可能需要创建')
    } else if (error.code === '42P04') {
      console.log(`ℹ️  数据库 "${targetDatabase}" 已存在`)
      return true
    }
    
    return false
  } finally {
    await pool.end()
  }
}

async function initializeDatabase() {
  try {
    console.log('🚀 开始初始化 AIDE 数据库...')
    
    // 显示解析后的配置
    const config = getDatabaseConfig()
    console.log('📋 解析后的数据库配置:')
    console.log(`   主机: ${config.host}:${config.port}`)
    console.log(`   数据库: ${config.database}`)
    console.log(`   用户: ${config.user}`)
    console.log(`   密码: ${config.password ? '***(' + config.password.length + '字符)' : '未设置'}`)
    
    // 首先确保数据库存在
    console.log('\n1️⃣ 检查并创建数据库...')
    const dbCreated = await createDatabase()
    if (!dbCreated) {
      console.error('\n❌ 数据库创建失败')
      console.error('🛠️  手动解决方案:')
      console.error(`   1. 登录PostgreSQL: psql -U ${config.user} -h ${config.host} -d postgres`)
      console.error(`   2. 创建数据库: CREATE DATABASE "${config.database}";`)
      console.error('   3. 重新运行此脚本')
      throw new Error('数据库创建失败')
    }
    
    // 连接到目标数据库
    console.log('\n2️⃣ 连接到目标数据库...')
    const pool = new Pool(config)
    const client = await pool.connect()
    console.log('✅ 数据库连接成功')
    
    // 读取初始化SQL文件
    console.log('\n3️⃣ 读取初始化脚本...')
    const sqlPath = path.join(__dirname, 'src', 'database', 'init.sql')
    if (!fs.existsSync(sqlPath)) {
      throw new Error(`初始化SQL文件不存在: ${sqlPath}`)
    }
    
    const initSQL = fs.readFileSync(sqlPath, 'utf8')
    console.log('✅ 初始化SQL脚本读取成功')
    
    // 执行初始化SQL
    console.log('\n4️⃣ 执行数据库初始化...')
    await client.query(initSQL)
    console.log('✅ 数据库表结构创建成功')
    
    // 检查表是否创建成功
    console.log('\n5️⃣ 验证表结构...')
    const tablesResult = await client.query(`
      SELECT table_name 
      FROM information_schema.tables 
      WHERE table_schema = 'public' 
      ORDER BY table_name;
    `)
    
    const tables = tablesResult.rows.map(row => row.table_name)
    console.log(`✅ 成功创建 ${tables.length} 个表:`)
    tables.forEach(table => {
      console.log(`   - ${table}`)
    })
    
    // 检查索引
    const indexesResult = await client.query(`
      SELECT indexname 
      FROM pg_indexes 
      WHERE schemaname = 'public' 
      AND indexname LIKE 'idx_%'
      ORDER BY indexname;
    `)
    
    const indexes = indexesResult.rows.map(row => row.indexname)
    console.log(`✅ 创建了 ${indexes.length} 个索引`)
    
    // 检查版本信息
    const versionResult = await client.query('SELECT version, applied_at FROM schema_versions ORDER BY applied_at DESC LIMIT 1')
    if (versionResult.rows.length > 0) {
      const { version, applied_at } = versionResult.rows[0]
      console.log(`📌 数据库版本: ${version} (${applied_at.toISOString()})`)
    }
    
    client.release()
    await pool.end()
    
    console.log('\n🎉 数据库初始化完成!')
    console.log('🚀 现在可以启动AIDE应用了')
    
  } catch (error) {
    console.error('\n❌ 数据库初始化失败:', error.message)
    
    // 提供详细的调试信息
    if (process.env.DATABASE_URL) {
      console.error('\n🔍 DATABASE_URL调试信息:')
      console.error('   原始URL:', process.env.DATABASE_URL)
      try {
        const parsed = parseDatabaseUrl(process.env.DATABASE_URL)
        console.error('   解析结果:', {
          user: parsed.user,
          password: parsed.password ? '***' : '未设置',
          host: parsed.host,
          port: parsed.port,
          database: parsed.database
        })
      } catch (parseError) {
        console.error('   解析错误:', parseError.message)
      }
    }
    
    process.exit(1)
  }
}

// 如果直接运行此脚本
if (require.main === module) {
  initializeDatabase()
}

module.exports = { initializeDatabase }
